Python 列表

本章我们将系统学习什么是Python列表、创建列表、列表索引和切片、列表循环遍历、列表增3种方法、列表修改、列表查询4种方法、列表删除3种方法、列表排序2种方法、列表复制、列表是可变类型、列表的常用方法汇总等知识。

什么是Python列表

本节我们来学习什么是Python的列表，什么是列表呢？列表这个词是由英文单词list翻译过来的。我们先来看一下这个list还有哪些含义？

除了列表以外，它还有个清单和目录，列表不好理解，清单目录我们比较熟悉 来看一下日常生活中有哪些常见的清单。 下面是我3月份的购物清单，5号我买了康师傅方便面，这个我记错的，我就把它删了，8号又买了雪糕。

通过这个清单中，比如说我1号买了康师傅，4号我又买了康师傅，大家应该能够总结出列表它的特点：

• 列表的特点就是数据可以重复的。
• 数据类型可以不同，在列表中我们可以存整形、浮点型、字符串类型、列表，元组，字典等等
• 可以在列表中新增元素
• 可以删除一些不需要的元素

创建列表

那下面我们来看一下，如何创建这个列表呢？那么有两种方式

1. 直接为列表赋值

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面']

现在我们就通过赋值的方式来创建了一个列表， 注意在列表中用逗号来分割每一个元素 。我们使用type函数来检测一下这个列表的类型。

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面']
print(type(ood_list))

输出结果：

<class 'list'>

我们再看一下列表中的元素，列表中用逗号分割的，全被称之为元素，上面的列表它的元素类型是字符串类型，我们再来添加几个其它的类型：整形，浮点型。我们还可以添加一个列表，在列表里还可以嵌套列表，这就相当于什么呢？就相当于我们现在有一个年度清单，这个年度清单里肯定包含每个月的，比如说3月份，此外还有4月份清单，它们都是一个list。

那么年度清单这个列表里就有两个列表，所以说在列表里可以嵌套列表。

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面', 18, 8.88, [1, 2, 3]]

2. 创建空列表

我们要创建Python的列表，可以使用方括号[]和list()方法，下面我们用示例的方式展示一下。

实例

实例1：使用[]创建空列表

list1 = []
print(type(list1))

输出结果：

<class 'list'>

实例2：使用list()方法创建空列表

list1 = list()
print(type(list1))

输出结果：

<class 'list'>

实例3：使用list()方法转换为列表

string_value = 'python'
list_word = list(string_value)
print(list_word)

输出结果：

['p', 'y', 't', 'h', 'o', 'n']

列表索引和切片

在介绍字符串的时候，我们介绍了索引和切片，而列表它也是支持索引和切片的，列表的索引和切片是操作列表中元素的常用方法。索引主要用于访问列表中的单个元素，而切片则用于访问列表中的一段元素序列。

1. 列表索引

列表索引是通过在方括号中指定元素的位置来访问列表中的元素。Python中的列表索引从0开始，也就是说，第一个元素的索引为0，第二个元素的索引为1，以此类推。列表的最后一个元素的索引为-1，倒数第二个元素的索引为-2，以此类推。

语法

list[index]

其中，list表示要访问的列表，index表示要访问的元素的索引。

实例

实例1：获取列表的元素

这里有一个列表，food_list它有4个元素，方便面，鸭货，啤酒和香肠，它在内存中是这样存储的，每一个元素都对应着一个索引，索引分别是0 1 2 3，我们要如何查找列表中的元素呢？和字符串一样，通过索引来查找。

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面', 18, 8.88, [1, 2, 3]]
print(food_list[0])     #获取列表第1个元素
print(food_list[1])     #获取列表第2个元素
print(food_list[2])     #获取列表第3个元素
print(food_list[3])     #获取列表第4个元素
print(food_list[4])     #获取列表第5个元素

输出结果：

康师傅方便面
酸奶
雪糕
康师傅方便面
18

实例2：用倒数的方式，来获取列表的元素

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面', 18, 8.88, [1, 2, 3]]
print(food_list[-1])     #获取列表倒数第1个元素
print(food_list[-2])     #获取列表倒数第2个元素
print(food_list[-3])     #获取列表倒数第3个元素
print(food_list[-4])     #获取列表倒数第4个元素

输出结果：

[1, 2, 3]
8.88
18
康师傅方便面

2. 列表切片

列表切片是通过在方括号中指定元素的起始位置和结束位置来访问列表中的一段元素序列。

语法为：

list[start:end:step]

list表示要访问的列表，start表示要访问的元素序列的起始位置（包含该位置的元素），end表示要访问的元素序列的结束位置（不包含该位置的元素），step表示访问元素序列时的步长（默认为1）。

实例3：列表切片常用示例

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面', 18, 8.88, [1, 2, 3]]
print(food_list[0:3])  # 访问列表中的前三个元素
print(food_list[1:3])  # 访问列表中的第二个和第三个元素
print(food_list[-2:])  # 访问列表中的后两个元素
print(food_list[::2])  # 访问列表中的所有元素，步长为2
print(food_list[-1][0:2])  # 访问列表中的最后一个列表中的前两个元素

['康师傅方便面', '酸奶', '雪糕']
['酸奶', '雪糕']
[8.88, [1, 2, 3]]
['康师傅方便面', '雪糕', 18, [1, 2, 3]]
[1, 2]

需要注意的是，当省略start时，默认为0；当省略end时，默认为列表的长度；当step为负数时，表示反向访问元素序列。

作业

作业一：列表索引切片作业练习题

words = ['daxiong', 'ketang', 'andy', 'python', 'xiaoxiong', 'java', 'c', 'C++', 'spider', 'flask']

• 输出列表中的第3个元素；
• 输出列表中的前5个元素；
• 输出列表中的最后3个元素；
• 输出列表中的第2个到第5个元素；
• 输出列表中的所有偶数元素；

获得作业答案请联系本笔记的配套视频：Python零基础入门动画课【全集】

列表循环遍历

为了更有效的输出列表中的每个数据，通常我们会使用列表的循环和遍历，在讲解循环和遍历的时候，我们介绍过两个语句，第1个for循环，第2个while循环，本节我们就使用for循环和while循环来遍历列表。

1. for循环遍历列表这

语法：

for 变量名 in 列表名:
    执行语句

其中，变量名为循环变量，用于依次代表列表中的每个元素；列表名为需要循环遍历的列表。

在循环过程中，每次循环都会将列表中的一个元素赋值给循环变量，并执行一次执行语句。执行语句可以是任意合法的Python语句，包括条件判断语句、函数调用语句等等。

实例

实例1：演示如何使用for循环语句遍历列表：

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面']
for food in food_list:
    print(food)

在上面的例子中，使用for循环语句遍历food_list中的每个元素，并将其赋值给循环变量food。在每次循环中，我们通过print语句将food的值输出。

运行上面的代码，输出结果如下：

康师傅方便面
酸奶
雪糕
康师傅方便面

可以看到，for循环语句遍历了my_list中的每个元素，并将其输出到了屏幕上。

实例2：使用range函数遍历列表

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面']
for i in range(len(food_list)):
    print(food_list[i])

输出结果：

康师傅方便面
酸奶
雪糕
康师傅方便面

2. while循环遍历列表

我们再来看使用while循环，使用while循环，为了能够让循环退出，我们需要知道这个列表的长度，获取列表的长度依然使用这个len函数。

实例3：使用while函数遍历列表

food_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面']
length = len(food_list)
i = 0
while i<length:
    print(food_list[i])
    i+=1

输出结果：

康师傅方便面
酸奶
雪糕
康师傅方便面

3. 遍历二维列表

那么如果这个列表中还有列表呢？应该如何循环遍历呢？来看一下列表中嵌套列表，创建三个子列表，然后我创建一个新的列表叫做food_list，在这个列表中有三个元素，第1个元素就是food_list[1]，第2个food_list[2]，food_list[3]。

实例4：遍历二维列表

food_list1 = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面']
food_list2 = ['啤酒', '饮料', '矿泉水']
food_list3 = ['花生', '瓜子', '火腿肠']
food_list = [food_list1,food_list2,food_list3]
for item in food_list:
    print(item)
    for name in item:
        print(name)

输出结果：

['康师傅方便面', '酸奶', '雪糕', '康师傅方便面']
康师傅方便面
酸奶
雪糕
康师傅方便面
['啤酒', '饮料', '矿泉水']
啤酒
饮料
矿泉水
['花生', '瓜子', '火腿肠']
花生
瓜子
火腿肠

第1个输出的是food_list1列表，然后接着输出每一个元素，把这个列表中的元素依次遍历出来，第1个里层循环结束，接着来第2层，以此类推。 使用了一个循环嵌套，就遍历出了列表中的列表，也就是二维列表

4. enumerate函数获取索引

此外在开发的过程中，我们还需要知道遍历时这个列表的下标，这个也是非常常用的，要获取遍历元素的下标，我们需要使用一个函数叫做enumerate，通过它来获取。

实例5：enumerate函数获取索引

ffood_list = ['康师傅方便面', '酸奶', '雪糕', '康师傅方便面']
for i, value in enumerate(food_list):
    print(f'第{i+1}个元素的值是{value}')

输出结果：

第1个元素的值是康师傅方便面
第2个元素的值是酸奶
第3个元素的值是雪糕
第4个元素的值是康师傅方便面

作业

作业一：使用for循环语句遍历my_str = "Hello, world!"，并输出每个字符的ASCII码。

作业二：使用for循环语句遍历my_list = [1, 2, 3, 4, 5]，并输出每个元素的平方。

作业三：使用for循环语句遍历my_list = [1, 2, 3, 4, 5]，并输出所有偶数元素的和。

作业四：使用for循环语句遍历my_list = [1, 2, 3, 4, 5]，并输出所有元素的索引和值。

获得作业答案请联系本笔记的配套视频：Python零基础入门动画课【全集】

列表增3种方法

Python中的列表是一种非常常见的数据类型，它可以存储一系列元素。当我们需要向列表中添加元素时，Python提供了多种方法来实现。本文将介绍三种常见的方法：append()、extend()和insert()。

方法	作用	示例
append()	在列表末尾添加一个元素	my_list.append(5)
extend()	在列表末尾添加另一个列表中的所有元素	my_list.extend([6, 7, 8])
insert()	在指定位置插入一个元素	my_list.insert(2, "hello")

1. append()方法

append()方法是Python中最基本的列表添加元素的方法，它可以在列表的末尾添加一个元素。

语法：

list.append(obj)

其中，list是要添加元素的列表，obj是要添加的元素。

实例

实例1：使用append()方法向列表中添加元素：

books = ['西游记','水浒传' ]
books.append('三国演义')
print(books) 

输出结果为：

['西游记', '水浒传', '三国演义']

可以看到，'三国演义'被成功地添加到了列表的末尾。需要注意的是，append()方法只能添加一个元素，如果要添加多个元素，可以使用extend()方法。

2. insert()方法

insert()方法可以在列表的任意位置添加一个元素，它接受两个参数，第一个参数是要添加元素的位置，第二个参数是要添加的元素。其语法如下：

list.insert(index, obj)

其中，list是要添加元素的列表，index是要添加元素的位置，obj是要添加的元素。

实例2：使用insert()方法向列表中添加元素

我们现在添加一个红楼梦，由于红楼梦的文学地位在四大名著中排在首位，所以我想把它插到第一位置,那么就可以使用insert，同样是book这个列表，insert方法，第1个元素是插入的位置。这个位置是索引位置，索引从零开始计算，所以这里我们添加0表示第1个元素

books = ['西游记','水浒传' ]
books.append('三国演义')
books.insert(0,'红楼梦')
print(books)

输出结果为：

['红楼梦', '西游记', '水浒传', '三国演义']

可以看到，'红楼梦'被成功地添加到了列表的第1个位置。需要注意的是，如果要添加的元素是多个，可以使用extend()方法。

3. extend()方法

extend()方法可以在列表的末尾添加多个元素，它接受一个参数，这个参数可以是一个列表、元组、集合等可迭代对象。

语法如下：

list.extend(iterable)

其中，list是要添加元素的列表，iterable是可迭代对象。

实例：使用extend()方法向列表中添加多个元素：

我们再来创建一个列表，这个列表呢，存储的就是武侠书籍，列表名称就用Kungfu，值为天龙八部，笑傲江湖

books = ['红楼梦', '西游记', '水浒传', '三国演义']
kungfu = ['天龙八部', '笑傲江湖']
books.extend(kungfu)
print(books)

输出结果为：

['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']

可以看到，'天龙八部'和'笑傲江湖'被成功地添加到了列表的末尾。需要注意的是，如果要添加的元素只有一个，可以使用append()方法。

作业

作业一：创建一个空列表，使用append()方法把0-9添加到空列表，然后打印列表。

作业二：创建my_list = [1, 2, 3, 4, 5]，使用insert()方法将andy插入到列表的第3个位置。

作业三：把下面列表合并为一个列表，然后打印列表。

获得作业答案请联系本笔记的配套视频：Python零基础入门动画课【全集】

列表修改

本文将介绍Python中列表的修改方法，包括修改单个元素、修改多个元素等操作。

1. 修改单个元素

修改列表中的单个元素非常简单，只需要通过下标访问到该元素，并将其赋值为新的值即可。

语法如下：

list[index] = new_value

其中，list表示要修改的列表，index表示要修改的元素的下标，new_value表示新的值。

实例1：修改列表单个元素。

现在我想books列表中的天龙八部把它替换掉，替换成射雕英雄传

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']
books[4] = '射雕英雄传'
print(books)

输出结果：

['红楼梦', '西游记', '水浒传', '三国演义', '射雕英雄传', '笑傲江湖']

在上面的例子中，我们将books列表中下标为4的元素（即天龙八部）修改为射雕英雄传，输出结果为['红楼梦', '西游记', '水浒传', '三国演义', '射雕英雄传', '笑傲江湖']。

实例2：索引越界的错误。

需要注意的是：如果你替换一个不存在的索引，它就会抛出索引越界的错误。

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']
books[10] = '射雕英雄传'
print(books)

在这里book这个10肯定是没有了，因为它一共才6个元素，这里就为我们报错了 list assignment index out of range，索引越界了，所以小伙伴们在修改列表中元素的时候一定要注意，索引不要越界。

2. 修改多个元素

如果需要同时修改多个元素，可以使用Python中的切片（slice）操作。具体语法如下：

list[start:end] = new_values

其中，list表示要修改的列表，start表示起始下标，end表示结束下标（不包含），new_values表示新的值，可以是一个列表。下面通过一个实例来演示修改多个元素的操作。

实例2：修改多个元素

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']
books[4:6] = ['射雕英雄传','金瓶梅']
print(books)

输出结果：

['红楼梦', '西游记', '水浒传', '三国演义', '射雕英雄传', '金瓶梅']

列表查询4种方法

列表查询是一种非常基础的操作，它可以帮助我们快速地查找到列表中的元素。在Python中，列表查询主要有四种方法，分别是in、not in、count和index。

方法	作用	示例
in	判断元素是否在列表中，返回布尔值	2 in [1,2,3] 返回值为 True
not in	判断元素是否不在列表中，返回布尔值	4 not in [1,2,3] 返回值为 True
count()	返回列表中指定元素出现的次数	[1,2,2,3].count(2) 返回值为 2
index()	返回列表中第一次出现指定元素的位置，如果没有找到则报错	[1,2,3].index(2) 返回值为 1

1. in方法

in方法用于判断一个元素是否在列表中存在，如果存在则返回True，否则返回False。

语法如下：

element in list

其中，element表示需要查找的元素，list表示需要查找的列表。

实例

实例1：使用in查询是否在列表中：

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']
if '红楼梦' in books:
    print('红楼梦在图书列表中')
else:
    print('红楼梦不在图书列表中')

输出结果为：

红楼梦在图书列表中

2. not in方法

not in方法与in方法正好相反，它用于判断一个元素是否不在列表中存在，如果不存在则返回True，否则返回False。

语法如下：

element not in list

其中，element表示需要查找的元素，list表示需要查找的列表。

实例2：使用not in查询是否在列表中：

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']
if '红楼梦' not in books:
    print('红楼梦不在图书列表中')
else:
    print('红楼梦在图书列表中')

输出结果为：

红楼梦在图书列表中

3. index方法

index方法用于查找一个元素在列表中第一次出现的位置。

语法如下：

list.index(element[, start[, end]])

其中，element表示需要查找的元素，start表示查找的起始位置，end表示查找的结束位置。start和end是可选参数，如果不指定，则默认从列表的第一个元素开始查找到最后一个元素。

实例3：index方法查找列表中的元素

在这里添加一个book.append添加，添加到最后，再用index去查找这个索引，这个输出结果是0，也就是说它找的是第1个红楼梦，这个index方法与我们讲解字符串的时候是一样的，它会先找到第1个匹配的内容，找到以后后面的内容就不管了，直接输出第1个元素所在的索引位置

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']
books.append('红楼梦')
print(books)
print(books.index('红楼梦'))

输出结果：

['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖', '红楼梦']
0

需要注意的是，如果需要查找的元素不存在于列表中，则会抛出ValueError异常。

4. count方法

count方法用于统计一个元素在列表中出现的次数。它的语法如下：

list.count(element)

其中，element表示需要统计的元素，list表示需要查找的列表。下面是一个简单的示例：

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖','红楼梦']
print(books.count('红楼梦'))
print(books.count('红楼一梦'))

输出结果为：

2
0

作业

作业一：判断红楼梦是否在列表中存在，如果存在则输出该元素在列表中的位置，否则输出"not found"。

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖','红楼梦','红楼梦','红楼梦', '三国演义']

作业二：统计下面列表中红楼梦出现的次数。

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖','红楼梦','红楼梦','红楼梦', '三国演义']

作业三：统计下面列表中所有元素出现的次数，并输出出现次数最多的元素。

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖','红楼梦','红楼梦','红楼梦', '三国演义']

获得作业答案请联系本笔记的配套视频：Python零基础入门动画课【全集】

列表删除3种方法

本节我们来学习列表删除的3种方法，有时候我们需要从列表中删除某些元素，以便对列表进行重构或处理。Python提供了三种常用的方法来删除列表中的元素：del、pop和remove。

方法	作用	示例
del	删除指定位置的元素	a = [1,2,3]; del a[1] a 变成 [1,3]
pop()	删除指定位置的元素并返回该元素的值，如果不指定位置则默认删除最后一个元素	a = [1,2,3]; a.pop(1) a 变成 [1,3]，返回值为 2
remove()	删除第一次出现的指定元素	a = [1,2,3]; a.remove(2) a 变成 [1,3]

1. del方法

del方法是Python内置的语句，用于删除指定索引位置或切片范围内的元素。

语法格式：

del list[index]
del list[start:end]

index表示要删除的元素的索引位置，start和end分别表示要删除的切片范围的起始和结束位置。需要注意的是，使用del方法删除元素后，列表的长度会缩短。

实例1：删除指定索引位置的元素

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖','红楼梦']
del books[-1]
print(books)

输出结果：

['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']

实例2：删除切片范围内的元素

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖','红楼梦']
del books[1:3]
print(books)

输出结果：

['红楼梦', '三国演义', '天龙八部', '笑傲江湖', '红楼梦']

2. pop方法

pop方法也是用于删除指定索引位置的元素，但与del方法不同的是，pop方法会返回被删除的元素。

语法格式为：

list.pop(index)

index表示要删除的元素的索引位置。需要注意的是，如果不指定index参数，则默认删除列表中的最后一个元素。

实例3：pop删除指定索引位置的元素

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖','红楼梦']
removed_books = books.pop(2)
print(books)
print(removed_books)

输出结果：

['红楼梦', '西游记', '三国演义', '天龙八部', '笑傲江湖', '红楼梦']
水浒传

实例4：pop不指定index，删除最后一个元素

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖']
removed_books = books.pop()
print(books)
print(removed_books)

输出结果：

['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部']
笑傲江湖

3. remove方法

remove方法用于删除列表中第一个匹配到的元素。

语法格式为：

list.remove(element)   #element表示要删除的元素。

实例5：使用remove方法删除列表元素：

books = ['红楼梦', '西游记', '水浒传', '三国演义', '天龙八部', '笑傲江湖','红楼梦']
books.remove('红楼梦')
print(books)

需要注意的是，如果列表中不存在要删除的元素，则会抛出ValueError异常。

列表排序2种方法

本节我们来学习Python中的列表排序，我们有两种主要的排序方法：sort和reserve。

方法	作用	示例
sort()	对列表进行排序	a = [3, 1, 4, 1, 5, 9, 2, 6, 5] a.sort() print(a) 输出为[1, 1, 2, 3, 4, 5, 5, 6, 9]
reverse()	对列表进行反转	a = [3, 1, 4, 1, 5, 9, 2, 6, 5] a.reverse() print(a) 输出为[5, 6, 2, 9, 5, 1, 4, 1, 3]

1. sort方法

sort方法是Python中列表对象的一个内置方法，它可以对列表进行排序。sort方法有两种可选参数：reverse和key。

语法：

list.sort(reverse=True|False, key=myFunc)

参数说明：

• reverse：可选，如果reverse=True，则列表按照降序排列，否则按照升序排列。默认值为False。
• key：可选，用于指定排序的关键字。这个关键字可以是一个函数，也可以是一个lambda表达式。默认为None。

实例1：使用sort函数对一个列表进行升序排列

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort()
print(my_list)

输出结果：

[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

实例2：使用sort函数对一个列表进行降序排列

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort(reverse=True)
print(my_list)

输出结果：

[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

实例3：使用sort函数对列表按照字符串长度进行排序

my_list = ["daxiongketang", "andy", "讲python", "小熊"]
my_list.sort(key=len)
print(my_list)  

输出结果：

['小熊', 'andy', '讲python', 'daxiongketang']

实例4：使用sort函数对一个列表按照倒数第二个字母进行排序

my_list = ["daxiongketang", "andy", "python", "xiaoxiong"]
my_list.sort(key=lambda x:x[-2])
print(my_list)

输出结果：

['andy', 'daxiongketang', 'xiaoxiong', 'python']

2. reverse方法

reverse方法是Python中列表对象的另一个内置方法，它可以将列表中的元素倒序排列。

语法：

list.reverse()

实例5：使用reverse将列表中的元素倒序排列

list_val = [23,13,56,78,90]
list_val.reverse()
print(list_val)

输出结果：

[90, 78, 56, 13, 23]

列表复制

本节我们来学习列表复制。在实际的编程中，我们经常需要对列表进行复制操作。其中最常用的是copy()方法。

copy()方法用于复制一个列表。

语法：

list.copy()

返回值：返回一个新的列表，该列表是原列表的副本

实例

实例1：复制一个列表

list1 = [23,13,56,78,90]
list2 = list1.copy()
print(id(list1))
print(id(list2))
list2[0] = 100
print("list1:", list1)
print("list2:", list2)

输出结果：

4379075520
4379328320
list1: [23, 13, 56, 78, 90]
list2: [100, 13, 56, 78, 90]

由于list2是list1的副本，因此修改list2并不会影响list1。

实例2：浅复制和深复制对比

list1 = [[1, 2], [3, 4]]
list2 = list1.copy()
list2[0][1] = 100   # 修改list2
print("list1:", list1)
print("list2:", list2)

# 深复制该列表
import copy
list3 = copy.deepcopy(list1)
list3[0][1] = 200   # 修改list3
print("list1:", list1)
print("list3:", list3)

输出结果：

list1: [[1, 100], [3, 4]]
list2: [[1, 100], [3, 4]]
list1: [[1, 100], [3, 4]]
list3: [[1, 200], [3, 4]]

解释：当列表中包含嵌套列表时，使用copy()方法进行复制时，会产生浅复制。浅复制只会复制嵌套列表的引用，而不是嵌套列表本身。因此，当修改嵌套列表中的元素时，原列表和副本列表都会受到影响。如果想实现深度复制，可以使用copy模块中的deepcopy()方法。

列表是可变类型

前面在介绍字符串的时候，我们谈到了数据类型，一种是可变类型，一种是不可变类型，当时我们说字符串是不可变类型，因为字符串它是无法更改的，列表它是可变类型，在这里我向大家推荐一个学习的网址：Pythontutor.com，这个网址它可以实时展示Python运行的效果，为更好的帮助我们理解，Python的可变类型和不可变类型。

定义了两个列表a和b，它里面有都元素1、2、3 。那么在Python中这两个变量，是不是指向同一个值呢？也就是说他们是不是拥有同一个内存地址呢？我们来运行一下就会一目了然。

a = [1,2,3]
b = [1,2,3]

左侧是我们的代码编辑区，右侧结果显示区，绿色箭头表示已经执行，红色箭头表示下一步要执行。那么这里已经执行完了第一行，把一个列表复制给一个变量a然后看一下效果，Frames是变量a所在的位置，右侧Objects 是内存显示的地址。那么a和b它们之间是没有任何关系的。

接下来我来更改一下列表a中的值，我在a代表中添加点内容，a.append加一个元素 4。

这是我们看到这个a还是指向原来的列表，只是说在列表后面加了一个元素，所以说这列表它是可变的，你在后面追加元素，他的地址没有变化，这是添加一个元素的情况。

那么我在列表中再添加一个列表呢，我们看到下图中在a指向的这个列表中最后的位置，这个元素它也指向了一个新列表，为了更清晰的理解我们看一下输出的最终值。

然后我们再来看一下前面介绍的copy方法：a.copy，把它赋值给c。看一下在左侧这里又新增了一个变量c，我们看到a和c之间是没有任何关系的，他们两个是独立的，只是说这里a使用copy方法，创建了一个新的列表c，而c只是它的值和a相同，也就是说它的指向和a指向的是一样的，但是他们之间没有任何关系。

我们再来看把a赋值给d，看下什么效果，在左侧又新增了一个变量d，此时d和a他们的指向是完全一样的，当我更改a的时候，看一下会发生什么变化，d和a因为指向相同，a变化的时候d它的值也随之变化了。通过这种可视化的形式我们可以更好的理解列表，它是可变类型。

另外呢，我们还可以通过一个函数叫做id函数来看一下它在内存中的地址

a = [1,2,3]
b = [1,2,3]
a.append(4)
a.append([11,22,33])
a.append(5)
c = a.copy()
d = a
a.append(6)
print(id(a))
print(id(b))
print(id(c))
print(id(d))

输出结果：

4444087232
4444340032
4444339776
4444087232

a 和d的id是相同的,那么也就是说只有变量a和d它们指向同一个内存地址,一个变化，另一个会随之变化,而其余的事没有任何关系的,相互之间没有任何影响。

列表的常用方法

本节我们来介绍一下列表的常用方法汇总，列表是Python中最常用的数据类型，所以Python提供了非常多的操作列表的方法。下面按照使用程度的高低给大家做了一个字符串常用方法的表格，并且每个方法带超链接，点击方法名字，都有对各个方法的详细介绍。

方法名称	描述	使用频率
append()	在列表末尾添加新元素	非常频繁
extend()	将一个可迭代对象的元素添加到列表末尾	非常频繁
insert()	在指定位置插入新元素	非常频繁
remove()	删除第一个匹配的元素	非常频繁
pop()	删除并返回指定位置的元素	非常频繁
index()	返回第一个匹配元素的索引	非常频繁
count()	返回指定元素在列表中出现的次数	非常频繁
sort()	对列表进行排序	非常频繁
reverse()	反转列表	非常频繁
copy()	返回列表的浅拷贝	非常频繁
clear()	删除列表中的所有元素	经常使用
len()	返回列表中元素的个数	经常使用
max()	返回列表中最大的元素	经常使用
min()	返回列表中最小的元素	经常使用
sum()	返回列表中所有元素的和	经常使用
any()	如果列表中任意一个元素为True，则返回True	有时使用
all()	如果列表中所有元素都为True，则返回True	有时使用
join()	将列表中的元素连接成一个字符串	有时使用
sorted()	返回对列表进行排序后的新列表	有时使用
filter()	返回符合条件的元素组成的新列表	有时使用
map()	对列表中的每个元素进行操作后返回新列表	有时使用
reduce()	对列表中的元素进行累积操作	很少使用
deepcopy()	返回列表的深拷贝	有时使用
slice()	返回指定范围内的元素组成的新列表	有时使用